home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / hard / drivr / BetaScan_1.12.lha / BetaScan / ScannerDev / ScanMakerE3.c < prev    next >
C/C++ Source or Header  |  1998-10-04  |  18KB  |  676 lines
  1. //*********************************************************************
  2. //
  3. //                 ScanmakerE3 Scanner device
  4. //
  5. //                    version 98.07.18
  6. //
  7. //*********************************************************************
  8.  
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11. #include <signal.h>
  12. #include <string.h>
  13. #include <math.h>
  14.  
  15. #include <exec/types.h>
  16. #include <proto/exec.h>
  17. #include <proto/dos.h>
  18.  
  19. #include "scsi.h"
  20.  
  21. #include "Scanner.h"
  22.  
  23. char DevName[] = "ScanmakerE3.device";
  24. char DevIdString[] = "ScanmakerE3";
  25.  
  26. typedef unsigned char ScanCmd[6];
  27.  
  28. // Scanner specifik defines
  29. #define MAX_BASE_RES      300
  30. #define MAX_EXT_RES       300
  31.  
  32. // scanning modes
  33. #define SCANMODE_HALFTONE   0
  34. #define SCANMODE_BW         1 
  35. #define SCANMODE_GREY       2
  36. #define SCANMODE_COLOR      3
  37.  
  38.  
  39. #define SCANBUFSIZE     32000
  40.  
  41. #define MAX_BUSY_RETRY      5
  42.  
  43.  
  44. static UBYTE* scanBuffer = NULL;
  45.  
  46. // Stored scanning parameters
  47. //
  48. static double x0;             /* Scanning frame in mm               */
  49. static double y0;
  50. static double x1;
  51. static double y1;
  52. static UBYTE  resolutionCode; /* Resolution in % of max resolution  */
  53. static UBYTE  resolutionFlag; /* Further resolution information     */
  54. static WORD   brightness[3];  /* Brightness for red, green and blue */
  55. static WORD   contrast;       /* Contrast                           */
  56. static WORD   shadow;         /* shadow adjust 0..1023 (default 0)  */
  57. static WORD   highlight;      /* highlight adjust 0..1023 (def. 0)  */
  58. static WORD   midtone;        /* midtone adjust 0..1023 (def. 512)  */
  59. static WORD   halftonePattern;/* halftonePattern 0..255 (def. 0)    */
  60. static WORD   exposureTime;   /* Exposure time                      */
  61. static double gamma;          /* gamma value                        */
  62. static WORD   scanMode;       /* see above                          */
  63. static BOOL   extendedRes;    /* extended resolution                */
  64. static BOOL   parametersSet;  /* parameters are set                 */
  65.  
  66. // Actual scanning values
  67. //
  68. static UWORD imageWidth;
  69. static UWORD imageHeight;
  70. static UWORD bytesPerLine;
  71. static UWORD xResolution;
  72. static UWORD yResolution;
  73.  
  74. // Parameters used during scanning
  75. //
  76. static BOOL scanning;    /* Scanner is scanning                                */
  77. static int  lineWidth;   /* Length of one scan line including color informat.  */
  78. static int  scanLines;   /* Total number of lines to read from scanner         */
  79. static int  numPlanes;   /* 3 for rgb24, otherwise 1                           */
  80. static int  bufferLen;   /* Length of scanBuffer in number of lines            */
  81. static int  linesRead;   /* Lines already read from scanner                    */
  82. static int  linesInBuf;  /* Number of lines read from scanner in scanBuffer    */
  83. static int  currentLine; /* Next line from scanBuf to return to user           */
  84. static int  nextPlane;   /* next plane number to return to readScanLine        */
  85.  
  86. //
  87. // Make color correction table brightness and contrast
  88. //
  89.  
  90. UBYTE corrTab[256];
  91.  
  92. void makeCorrTab(int bright,int contrast)
  93. {
  94.   int    i,b,c;
  95.   UBYTE* tab;
  96.  
  97.   tab = corrTab;
  98.   bright = (bright*255)/100;
  99.   c = 100+contrast;
  100.   for( i = 0 ; i < 256 ; i++ )
  101.   {
  102.     b = ((i+bright)*c-50*contrast)/100;
  103.     *(tab++) = b>255?255:(b<0?0:(UBYTE)b);
  104.   }
  105. }
  106.  
  107. /*------------------------------------------------------------------------*/
  108. static void scannerReady(BYTE *error)
  109. {
  110.   if( *error == 0 )
  111.   {
  112.     ScanCmd TEST_UNIT_READY = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  113.     int retry = 0;
  114.  
  115.     while( sendCommand(TEST_UNIT_READY, 6, NULL, 0, NULL, 0) )
  116.     {
  117.       retry++;
  118.       if (retry == 5)
  119.       {
  120.         *error = SCAN_ERR_READY;
  121.         return;
  122.       }
  123.       Delay(3*50);
  124.     }
  125.   }
  126. }
  127.  
  128.  
  129. /*------------------------------------------------------------------------*/
  130. static void setScanningFrame(BYTE *error)
  131. {
  132.   if( *error == 0 )
  133.   {
  134.     ScanCmd SCANNING_FRAME = { 0x04, 0x00, 0x00, 0x00, 0x09, 0x00 };
  135.     UBYTE   frame_data[9];
  136.  
  137.     int xf0,yf0,xf1,yf1;
  138.     int dpi;
  139.     
  140.     frame_data[0] = 0x00;
  141.     if( scanMode == SCANMODE_HALFTONE )
  142.       frame_data[0] |= 0x01;
  143.  
  144.     // Unit is pixel
  145.     //
  146.     frame_data[0] |= 0x08;
  147.  
  148.     dpi = MAX_BASE_RES;
  149.     xf0 = (int)((double)(x0*dpi)/25.4);
  150.     yf0 = (int)((double)(y0*dpi)/25.4);
  151.     xf1 = (int)((double)(x1*dpi)/25.4);
  152.     yf1 = (int)((double)(y1*dpi)/25.4);
  153.     
  154.     frame_data[1] = (UBYTE)(xf0 & 0xff);
  155.     frame_data[2] = (UBYTE)((xf0 & 0xff00) >> 8);
  156.     frame_data[3] = (UBYTE)(yf0 & 0xff);
  157.     frame_data[4] = (UBYTE)((yf0 & 0xff00) >> 8);
  158.     frame_data[5] = (UBYTE)(xf1 & 0xff);
  159.     frame_data[6] = (UBYTE)((xf1 & 0xff00) >> 8);
  160.     frame_data[7] = (UBYTE)(yf1 & 0xff);
  161.     frame_data[8] = (UBYTE)((yf1 & 0xff00) >> 8);
  162.  
  163.     *error = sendCommand(SCANNING_FRAME, 6, frame_data, 9, NULL, 0);
  164.   }
  165. }
  166.  
  167.  
  168. /*------------------------------------------------------------------------*/
  169. static void selectMode(BYTE *error)
  170. {
  171.   if( *error == 0 )
  172.   {
  173.     ScanCmd MODE_SELECT = { 0x15, 0x00, 0x00, 0x00, 0x0B, 0x00 };
  174.     UBYTE mode_data[11];
  175.  
  176.     mode_data[0] = 0x81;
  177.     
  178.     // Set resolution
  179.     mode_data[0] |= 0x02;
  180.     mode_data[1] = resolutionCode;
  181.     mode_data[2] = (exposureTime/3)+7;
  182.     mode_data[3] = (contrast+49)/7;
  183.     mode_data[4] = halftonePattern;
  184.     mode_data[5] = 0x01;
  185.     mode_data[6] = shadow;
  186.     mode_data[7] = highlight;
  187.     mode_data[8] = 0x6C;
  188.     mode_data[9] = 0x00;
  189.     mode_data[10] = midtone;
  190.         
  191.     *error = sendCommand(MODE_SELECT, 6, mode_data, 11, NULL, 0);
  192.   }
  193. }
  194.  
  195. /*------------------------------------------------------------------------*/
  196. void mode_sense_1(BYTE *error)
  197. {
  198.  
  199.   if( *error == 0 )
  200.   {
  201.     ScanCmd MODE_SELECT_1 = { 0x16, 0x00, 0x00, 0x00, 0x0a, 0x00 };
  202.     unsigned char mode_data[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  203.  
  204.     mode_data[1] = (UBYTE)(brightness[0]);
  205.  
  206.     *error = sendCommand(MODE_SELECT_1, 6, mode_data, 10, NULL, 0);
  207.   }
  208.   if( *error == 0 )
  209.   {
  210.     ScanCmd MODE_SENSE_1 = { 0x19, 0x00, 0x00, 0x00, 0x1e, 0x00 };
  211.     unsigned char mode_data[30] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  212.                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  213.                                     0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  214.  
  215.     mode_data[1] = (UBYTE)(brightness[0]);
  216.     mode_data[2] = (UBYTE)(brightness[1]);
  217.     mode_data[3] = (UBYTE)(brightness[2]);
  218.     *error = sendCommand(MODE_SENSE_1, 6, mode_data, 30, NULL, 0);
  219.   }
  220. }
  221.  
  222. /*------------------------------------------------------------------------*/
  223. /* int lut_download (char filter, char *gtable, int gt_entries)           */
  224. /* Issue the LOOK-UP-TABLE DOWNLOAD command to the scanner to download    */
  225. /* the gamma table pointed to by <gtable>. <filter> determines the color  */
  226. /* to which the table applies (RED, GREEN, BLUE, or CLEAR; values other   */
  227. /* than CLEAR may only be specified for one-pass color scanners). The     */
  228. /* number of entries is determined by <entries> (256, 1024, 4096 or       */
  229. /* 65536). The entry width is automatically assumed to be one byte if the */
  230. /* number of entries is 256 and two bytes otherwise.                      */
  231. /*------------------------------------------------------------------------*/
  232.  
  233. void gammaTable(double g, BYTE *error)
  234. {
  235.   if( *error == 0 )
  236.   {
  237.     UBYTE LUT_DOWNLOAD[10] = {0x55,0x00,0x27,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
  238.     UBYTE gTable[256];
  239.     int i;
  240.  
  241.     LUT_DOWNLOAD[7] = (UBYTE)((256 & 0xff00) >> 8);
  242.     LUT_DOWNLOAD[8] = (UBYTE)(256 & 0xff);
  243.  
  244.     if( (g <= 0.0) || (g == 1.0) )
  245.     {
  246.       for( i = 0 ; i < 256 ; i++ )
  247.         gTable[i] = (UBYTE)i;
  248.     }
  249.     else
  250.     {
  251.       for( i = 0 ; i < 256 ; i++ )
  252.         gTable[i] = (UBYTE)(256.0*pow(((double)i)/256.0,1/g));
  253.     }
  254.  
  255.     *error = sendCommand(LUT_DOWNLOAD,10,gTable,256,NULL,0);
  256.   }
  257. }
  258.  
  259. /*------------------------------------------------------------------------*/
  260. static void accessory(BYTE *error)
  261. {
  262.   if( *error == 0 )
  263.   {
  264.     ScanCmd ACCESSORY = { 0x10, 0x00, 0x00, 0x00, 0x9A, 0x00 };
  265.  
  266.     *error = sendCommand(ACCESSORY, 6, NULL, 0, NULL, 0);
  267.   }
  268. }
  269.  
  270. /*------------------------------------------------------------------------*/
  271. static void startScan(BYTE *error)
  272. {
  273.   if( *error == 0 )
  274.   {
  275.     ScanCmd START_SCAN = { 0x1b, 0x00, 0x00, 0x00, 0x01, 0x00 };
  276.  
  277.     switch( scanMode )
  278.     {
  279.